I understand the primary motivation is to abstract the communication and debug streams.

I'd like to summarize the current pattern with NoteLog since NoteSerial follows the same pattern, and begin and setDebugOutputStream also follow a similar pattern, so I'll choose setDebugOutputStream.

Calling Notecard::setDebugOutputStream() follows these steps

1. The caller passes the arduino Stream to the call. The type is NoteLog::channel_t which is void*

2. Inside the notecard implementation make_note_log is called, which takes the void* to the stream and creates a NoteLog_Arduino instance, which requires a Stream* - the void* stream is statically cast to Stream*.

3. NoteLog is a polymorphic interface, with a virtual method print.

The main concerns here is that it isn't type-safe, and there's a tight coupling between the caller and the make_note_log implementation. But thanks to the NoteLog interface, this can be easily fixed in a type-safe way and without the tight coupling. We can also still maintain the singleton instance required too.

#ifdef ARDUINO
// Arduino-specific override
void setDebugOutput(Stream* stream) {
     setDebugOutput(new NoteLog_Arduino(stream));
}
#endif
void setDebugOutput(NoteLog* log) {
    // set the global instance
    note_log = log;
}
private:
   static NoteLog* note_log;

Then when we want to implement this for a different streaming platform, e.g. C stdio, then we can just create a new NoteLog subclass

class NoteLog_stdio : public NoteLog {
    OStream* stream;
    void print(const char* c) {
        stream->write(c);
    }
}

And use that as the debug stream

notecard.setDebugOutput(new NoteLog_stdio(&cout));

This lets the caller choose what type of stream they want, rather than it being fixed by make_note_log and type-safety is provided.

To sum up - the key change is to pass around NoteLog instances rather than the implementation specific NoteLog::channel_t which is merely a catch-all type.